/*
 * XML Type:  InvestmentOpenOrderList
 * Namespace: http://ofx.net/types/2003/04
 * Java type: net.ofx.types.x2003.x04.InvestmentOpenOrderList
 *
 * Automatically generated - do not modify.
 */
package net.ofx.types.x2003.x04.impl;
/**
 * An XML InvestmentOpenOrderList(@http://ofx.net/types/2003/04).
 *
 * This is a complex type.
 */
public class InvestmentOpenOrderListImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements net.ofx.types.x2003.x04.InvestmentOpenOrderList
{
    
    public InvestmentOpenOrderListImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName OOBUYDEBT$0 = 
        new javax.xml.namespace.QName("", "OOBUYDEBT");
    private static final javax.xml.namespace.QName OOBUYMF$2 = 
        new javax.xml.namespace.QName("", "OOBUYMF");
    private static final javax.xml.namespace.QName OOBUYOPT$4 = 
        new javax.xml.namespace.QName("", "OOBUYOPT");
    private static final javax.xml.namespace.QName OOBUYOTHER$6 = 
        new javax.xml.namespace.QName("", "OOBUYOTHER");
    private static final javax.xml.namespace.QName OOBUYSTOCK$8 = 
        new javax.xml.namespace.QName("", "OOBUYSTOCK");
    private static final javax.xml.namespace.QName OOSELLDEBT$10 = 
        new javax.xml.namespace.QName("", "OOSELLDEBT");
    private static final javax.xml.namespace.QName OOSELLMF$12 = 
        new javax.xml.namespace.QName("", "OOSELLMF");
    private static final javax.xml.namespace.QName OOSELLOPT$14 = 
        new javax.xml.namespace.QName("", "OOSELLOPT");
    private static final javax.xml.namespace.QName OOSELLOTHER$16 = 
        new javax.xml.namespace.QName("", "OOSELLOTHER");
    private static final javax.xml.namespace.QName OOSELLSTOCK$18 = 
        new javax.xml.namespace.QName("", "OOSELLSTOCK");
    private static final javax.xml.namespace.QName SWITCHMF$20 = 
        new javax.xml.namespace.QName("", "SWITCHMF");
    
    
    /**
     * Gets array of all "OOBUYDEBT" elements
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyDebt[] getOOBUYDEBTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(OOBUYDEBT$0, targetList);
            net.ofx.types.x2003.x04.OpenOrderBuyDebt[] result = new net.ofx.types.x2003.x04.OpenOrderBuyDebt[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "OOBUYDEBT" element
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyDebt getOOBUYDEBTArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyDebt target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyDebt)get_store().find_element_user(OOBUYDEBT$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "OOBUYDEBT" element
     */
    public int sizeOfOOBUYDEBTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(OOBUYDEBT$0);
        }
    }
    
    /**
     * Sets array of all "OOBUYDEBT" element
     */
    public void setOOBUYDEBTArray(net.ofx.types.x2003.x04.OpenOrderBuyDebt[] oobuydebtArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(oobuydebtArray, OOBUYDEBT$0);
        }
    }
    
    /**
     * Sets ith "OOBUYDEBT" element
     */
    public void setOOBUYDEBTArray(int i, net.ofx.types.x2003.x04.OpenOrderBuyDebt oobuydebt)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyDebt target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyDebt)get_store().find_element_user(OOBUYDEBT$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(oobuydebt);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "OOBUYDEBT" element
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyDebt insertNewOOBUYDEBT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyDebt target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyDebt)get_store().insert_element_user(OOBUYDEBT$0, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "OOBUYDEBT" element
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyDebt addNewOOBUYDEBT()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyDebt target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyDebt)get_store().add_element_user(OOBUYDEBT$0);
            return target;
        }
    }
    
    /**
     * Removes the ith "OOBUYDEBT" element
     */
    public void removeOOBUYDEBT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OOBUYDEBT$0, i);
        }
    }
    
    /**
     * Gets array of all "OOBUYMF" elements
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyMutualFund[] getOOBUYMFArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(OOBUYMF$2, targetList);
            net.ofx.types.x2003.x04.OpenOrderBuyMutualFund[] result = new net.ofx.types.x2003.x04.OpenOrderBuyMutualFund[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "OOBUYMF" element
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyMutualFund getOOBUYMFArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyMutualFund target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyMutualFund)get_store().find_element_user(OOBUYMF$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "OOBUYMF" element
     */
    public int sizeOfOOBUYMFArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(OOBUYMF$2);
        }
    }
    
    /**
     * Sets array of all "OOBUYMF" element
     */
    public void setOOBUYMFArray(net.ofx.types.x2003.x04.OpenOrderBuyMutualFund[] oobuymfArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(oobuymfArray, OOBUYMF$2);
        }
    }
    
    /**
     * Sets ith "OOBUYMF" element
     */
    public void setOOBUYMFArray(int i, net.ofx.types.x2003.x04.OpenOrderBuyMutualFund oobuymf)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyMutualFund target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyMutualFund)get_store().find_element_user(OOBUYMF$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(oobuymf);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "OOBUYMF" element
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyMutualFund insertNewOOBUYMF(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyMutualFund target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyMutualFund)get_store().insert_element_user(OOBUYMF$2, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "OOBUYMF" element
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyMutualFund addNewOOBUYMF()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyMutualFund target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyMutualFund)get_store().add_element_user(OOBUYMF$2);
            return target;
        }
    }
    
    /**
     * Removes the ith "OOBUYMF" element
     */
    public void removeOOBUYMF(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OOBUYMF$2, i);
        }
    }
    
    /**
     * Gets array of all "OOBUYOPT" elements
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyOption[] getOOBUYOPTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(OOBUYOPT$4, targetList);
            net.ofx.types.x2003.x04.OpenOrderBuyOption[] result = new net.ofx.types.x2003.x04.OpenOrderBuyOption[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "OOBUYOPT" element
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyOption getOOBUYOPTArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyOption target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyOption)get_store().find_element_user(OOBUYOPT$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "OOBUYOPT" element
     */
    public int sizeOfOOBUYOPTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(OOBUYOPT$4);
        }
    }
    
    /**
     * Sets array of all "OOBUYOPT" element
     */
    public void setOOBUYOPTArray(net.ofx.types.x2003.x04.OpenOrderBuyOption[] oobuyoptArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(oobuyoptArray, OOBUYOPT$4);
        }
    }
    
    /**
     * Sets ith "OOBUYOPT" element
     */
    public void setOOBUYOPTArray(int i, net.ofx.types.x2003.x04.OpenOrderBuyOption oobuyopt)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyOption target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyOption)get_store().find_element_user(OOBUYOPT$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(oobuyopt);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "OOBUYOPT" element
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyOption insertNewOOBUYOPT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyOption target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyOption)get_store().insert_element_user(OOBUYOPT$4, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "OOBUYOPT" element
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyOption addNewOOBUYOPT()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyOption target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyOption)get_store().add_element_user(OOBUYOPT$4);
            return target;
        }
    }
    
    /**
     * Removes the ith "OOBUYOPT" element
     */
    public void removeOOBUYOPT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OOBUYOPT$4, i);
        }
    }
    
    /**
     * Gets array of all "OOBUYOTHER" elements
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyOther[] getOOBUYOTHERArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(OOBUYOTHER$6, targetList);
            net.ofx.types.x2003.x04.OpenOrderBuyOther[] result = new net.ofx.types.x2003.x04.OpenOrderBuyOther[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "OOBUYOTHER" element
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyOther getOOBUYOTHERArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyOther target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyOther)get_store().find_element_user(OOBUYOTHER$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "OOBUYOTHER" element
     */
    public int sizeOfOOBUYOTHERArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(OOBUYOTHER$6);
        }
    }
    
    /**
     * Sets array of all "OOBUYOTHER" element
     */
    public void setOOBUYOTHERArray(net.ofx.types.x2003.x04.OpenOrderBuyOther[] oobuyotherArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(oobuyotherArray, OOBUYOTHER$6);
        }
    }
    
    /**
     * Sets ith "OOBUYOTHER" element
     */
    public void setOOBUYOTHERArray(int i, net.ofx.types.x2003.x04.OpenOrderBuyOther oobuyother)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyOther target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyOther)get_store().find_element_user(OOBUYOTHER$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(oobuyother);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "OOBUYOTHER" element
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyOther insertNewOOBUYOTHER(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyOther target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyOther)get_store().insert_element_user(OOBUYOTHER$6, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "OOBUYOTHER" element
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyOther addNewOOBUYOTHER()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyOther target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyOther)get_store().add_element_user(OOBUYOTHER$6);
            return target;
        }
    }
    
    /**
     * Removes the ith "OOBUYOTHER" element
     */
    public void removeOOBUYOTHER(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OOBUYOTHER$6, i);
        }
    }
    
    /**
     * Gets array of all "OOBUYSTOCK" elements
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyStock[] getOOBUYSTOCKArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(OOBUYSTOCK$8, targetList);
            net.ofx.types.x2003.x04.OpenOrderBuyStock[] result = new net.ofx.types.x2003.x04.OpenOrderBuyStock[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "OOBUYSTOCK" element
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyStock getOOBUYSTOCKArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyStock target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyStock)get_store().find_element_user(OOBUYSTOCK$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "OOBUYSTOCK" element
     */
    public int sizeOfOOBUYSTOCKArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(OOBUYSTOCK$8);
        }
    }
    
    /**
     * Sets array of all "OOBUYSTOCK" element
     */
    public void setOOBUYSTOCKArray(net.ofx.types.x2003.x04.OpenOrderBuyStock[] oobuystockArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(oobuystockArray, OOBUYSTOCK$8);
        }
    }
    
    /**
     * Sets ith "OOBUYSTOCK" element
     */
    public void setOOBUYSTOCKArray(int i, net.ofx.types.x2003.x04.OpenOrderBuyStock oobuystock)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyStock target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyStock)get_store().find_element_user(OOBUYSTOCK$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(oobuystock);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "OOBUYSTOCK" element
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyStock insertNewOOBUYSTOCK(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyStock target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyStock)get_store().insert_element_user(OOBUYSTOCK$8, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "OOBUYSTOCK" element
     */
    public net.ofx.types.x2003.x04.OpenOrderBuyStock addNewOOBUYSTOCK()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderBuyStock target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderBuyStock)get_store().add_element_user(OOBUYSTOCK$8);
            return target;
        }
    }
    
    /**
     * Removes the ith "OOBUYSTOCK" element
     */
    public void removeOOBUYSTOCK(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OOBUYSTOCK$8, i);
        }
    }
    
    /**
     * Gets array of all "OOSELLDEBT" elements
     */
    public net.ofx.types.x2003.x04.OpenOrderSellDebt[] getOOSELLDEBTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(OOSELLDEBT$10, targetList);
            net.ofx.types.x2003.x04.OpenOrderSellDebt[] result = new net.ofx.types.x2003.x04.OpenOrderSellDebt[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "OOSELLDEBT" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSellDebt getOOSELLDEBTArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellDebt target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellDebt)get_store().find_element_user(OOSELLDEBT$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "OOSELLDEBT" element
     */
    public int sizeOfOOSELLDEBTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(OOSELLDEBT$10);
        }
    }
    
    /**
     * Sets array of all "OOSELLDEBT" element
     */
    public void setOOSELLDEBTArray(net.ofx.types.x2003.x04.OpenOrderSellDebt[] ooselldebtArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(ooselldebtArray, OOSELLDEBT$10);
        }
    }
    
    /**
     * Sets ith "OOSELLDEBT" element
     */
    public void setOOSELLDEBTArray(int i, net.ofx.types.x2003.x04.OpenOrderSellDebt ooselldebt)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellDebt target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellDebt)get_store().find_element_user(OOSELLDEBT$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(ooselldebt);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "OOSELLDEBT" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSellDebt insertNewOOSELLDEBT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellDebt target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellDebt)get_store().insert_element_user(OOSELLDEBT$10, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "OOSELLDEBT" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSellDebt addNewOOSELLDEBT()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellDebt target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellDebt)get_store().add_element_user(OOSELLDEBT$10);
            return target;
        }
    }
    
    /**
     * Removes the ith "OOSELLDEBT" element
     */
    public void removeOOSELLDEBT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OOSELLDEBT$10, i);
        }
    }
    
    /**
     * Gets array of all "OOSELLMF" elements
     */
    public net.ofx.types.x2003.x04.OpenOrderSellMutualFund[] getOOSELLMFArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(OOSELLMF$12, targetList);
            net.ofx.types.x2003.x04.OpenOrderSellMutualFund[] result = new net.ofx.types.x2003.x04.OpenOrderSellMutualFund[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "OOSELLMF" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSellMutualFund getOOSELLMFArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellMutualFund target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellMutualFund)get_store().find_element_user(OOSELLMF$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "OOSELLMF" element
     */
    public int sizeOfOOSELLMFArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(OOSELLMF$12);
        }
    }
    
    /**
     * Sets array of all "OOSELLMF" element
     */
    public void setOOSELLMFArray(net.ofx.types.x2003.x04.OpenOrderSellMutualFund[] oosellmfArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(oosellmfArray, OOSELLMF$12);
        }
    }
    
    /**
     * Sets ith "OOSELLMF" element
     */
    public void setOOSELLMFArray(int i, net.ofx.types.x2003.x04.OpenOrderSellMutualFund oosellmf)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellMutualFund target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellMutualFund)get_store().find_element_user(OOSELLMF$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(oosellmf);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "OOSELLMF" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSellMutualFund insertNewOOSELLMF(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellMutualFund target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellMutualFund)get_store().insert_element_user(OOSELLMF$12, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "OOSELLMF" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSellMutualFund addNewOOSELLMF()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellMutualFund target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellMutualFund)get_store().add_element_user(OOSELLMF$12);
            return target;
        }
    }
    
    /**
     * Removes the ith "OOSELLMF" element
     */
    public void removeOOSELLMF(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OOSELLMF$12, i);
        }
    }
    
    /**
     * Gets array of all "OOSELLOPT" elements
     */
    public net.ofx.types.x2003.x04.OpenOrderSellOption[] getOOSELLOPTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(OOSELLOPT$14, targetList);
            net.ofx.types.x2003.x04.OpenOrderSellOption[] result = new net.ofx.types.x2003.x04.OpenOrderSellOption[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "OOSELLOPT" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSellOption getOOSELLOPTArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellOption target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellOption)get_store().find_element_user(OOSELLOPT$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "OOSELLOPT" element
     */
    public int sizeOfOOSELLOPTArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(OOSELLOPT$14);
        }
    }
    
    /**
     * Sets array of all "OOSELLOPT" element
     */
    public void setOOSELLOPTArray(net.ofx.types.x2003.x04.OpenOrderSellOption[] ooselloptArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(ooselloptArray, OOSELLOPT$14);
        }
    }
    
    /**
     * Sets ith "OOSELLOPT" element
     */
    public void setOOSELLOPTArray(int i, net.ofx.types.x2003.x04.OpenOrderSellOption oosellopt)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellOption target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellOption)get_store().find_element_user(OOSELLOPT$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(oosellopt);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "OOSELLOPT" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSellOption insertNewOOSELLOPT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellOption target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellOption)get_store().insert_element_user(OOSELLOPT$14, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "OOSELLOPT" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSellOption addNewOOSELLOPT()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellOption target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellOption)get_store().add_element_user(OOSELLOPT$14);
            return target;
        }
    }
    
    /**
     * Removes the ith "OOSELLOPT" element
     */
    public void removeOOSELLOPT(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OOSELLOPT$14, i);
        }
    }
    
    /**
     * Gets array of all "OOSELLOTHER" elements
     */
    public net.ofx.types.x2003.x04.OpenOrderSellOther[] getOOSELLOTHERArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(OOSELLOTHER$16, targetList);
            net.ofx.types.x2003.x04.OpenOrderSellOther[] result = new net.ofx.types.x2003.x04.OpenOrderSellOther[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "OOSELLOTHER" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSellOther getOOSELLOTHERArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellOther target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellOther)get_store().find_element_user(OOSELLOTHER$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "OOSELLOTHER" element
     */
    public int sizeOfOOSELLOTHERArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(OOSELLOTHER$16);
        }
    }
    
    /**
     * Sets array of all "OOSELLOTHER" element
     */
    public void setOOSELLOTHERArray(net.ofx.types.x2003.x04.OpenOrderSellOther[] oosellotherArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(oosellotherArray, OOSELLOTHER$16);
        }
    }
    
    /**
     * Sets ith "OOSELLOTHER" element
     */
    public void setOOSELLOTHERArray(int i, net.ofx.types.x2003.x04.OpenOrderSellOther oosellother)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellOther target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellOther)get_store().find_element_user(OOSELLOTHER$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(oosellother);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "OOSELLOTHER" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSellOther insertNewOOSELLOTHER(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellOther target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellOther)get_store().insert_element_user(OOSELLOTHER$16, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "OOSELLOTHER" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSellOther addNewOOSELLOTHER()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellOther target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellOther)get_store().add_element_user(OOSELLOTHER$16);
            return target;
        }
    }
    
    /**
     * Removes the ith "OOSELLOTHER" element
     */
    public void removeOOSELLOTHER(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OOSELLOTHER$16, i);
        }
    }
    
    /**
     * Gets array of all "OOSELLSTOCK" elements
     */
    public net.ofx.types.x2003.x04.OpenOrderSellStock[] getOOSELLSTOCKArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(OOSELLSTOCK$18, targetList);
            net.ofx.types.x2003.x04.OpenOrderSellStock[] result = new net.ofx.types.x2003.x04.OpenOrderSellStock[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "OOSELLSTOCK" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSellStock getOOSELLSTOCKArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellStock target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellStock)get_store().find_element_user(OOSELLSTOCK$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "OOSELLSTOCK" element
     */
    public int sizeOfOOSELLSTOCKArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(OOSELLSTOCK$18);
        }
    }
    
    /**
     * Sets array of all "OOSELLSTOCK" element
     */
    public void setOOSELLSTOCKArray(net.ofx.types.x2003.x04.OpenOrderSellStock[] oosellstockArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(oosellstockArray, OOSELLSTOCK$18);
        }
    }
    
    /**
     * Sets ith "OOSELLSTOCK" element
     */
    public void setOOSELLSTOCKArray(int i, net.ofx.types.x2003.x04.OpenOrderSellStock oosellstock)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellStock target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellStock)get_store().find_element_user(OOSELLSTOCK$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(oosellstock);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "OOSELLSTOCK" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSellStock insertNewOOSELLSTOCK(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellStock target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellStock)get_store().insert_element_user(OOSELLSTOCK$18, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "OOSELLSTOCK" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSellStock addNewOOSELLSTOCK()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSellStock target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSellStock)get_store().add_element_user(OOSELLSTOCK$18);
            return target;
        }
    }
    
    /**
     * Removes the ith "OOSELLSTOCK" element
     */
    public void removeOOSELLSTOCK(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OOSELLSTOCK$18, i);
        }
    }
    
    /**
     * Gets array of all "SWITCHMF" elements
     */
    public net.ofx.types.x2003.x04.OpenOrderSwitchMutualFund[] getSWITCHMFArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SWITCHMF$20, targetList);
            net.ofx.types.x2003.x04.OpenOrderSwitchMutualFund[] result = new net.ofx.types.x2003.x04.OpenOrderSwitchMutualFund[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "SWITCHMF" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSwitchMutualFund getSWITCHMFArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSwitchMutualFund target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSwitchMutualFund)get_store().find_element_user(SWITCHMF$20, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "SWITCHMF" element
     */
    public int sizeOfSWITCHMFArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SWITCHMF$20);
        }
    }
    
    /**
     * Sets array of all "SWITCHMF" element
     */
    public void setSWITCHMFArray(net.ofx.types.x2003.x04.OpenOrderSwitchMutualFund[] switchmfArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(switchmfArray, SWITCHMF$20);
        }
    }
    
    /**
     * Sets ith "SWITCHMF" element
     */
    public void setSWITCHMFArray(int i, net.ofx.types.x2003.x04.OpenOrderSwitchMutualFund switchmf)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSwitchMutualFund target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSwitchMutualFund)get_store().find_element_user(SWITCHMF$20, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(switchmf);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "SWITCHMF" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSwitchMutualFund insertNewSWITCHMF(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSwitchMutualFund target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSwitchMutualFund)get_store().insert_element_user(SWITCHMF$20, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "SWITCHMF" element
     */
    public net.ofx.types.x2003.x04.OpenOrderSwitchMutualFund addNewSWITCHMF()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.OpenOrderSwitchMutualFund target = null;
            target = (net.ofx.types.x2003.x04.OpenOrderSwitchMutualFund)get_store().add_element_user(SWITCHMF$20);
            return target;
        }
    }
    
    /**
     * Removes the ith "SWITCHMF" element
     */
    public void removeSWITCHMF(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SWITCHMF$20, i);
        }
    }
}
